package s.f.empresas;

import s.f.jndi.ConexionJNDI;
import s.f.util.AppException;
import s.f.util.Conexion;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Clase destinada para el acceso a datos del Empresa.
 * @author froy
 */
public class CRUD_Empresas {

    public static int registrosAfectados;

    /**
     * Realiza una inserción de un Empresa.
     * @param empresa Solicita un objeto Empresa.
     * @throws AppException
     */
    public static void insertEmpresa(Empresas empresa) throws AppException {
        int index = 1;
        

        StringBuilder sb = new StringBuilder();
        sb.append("insert into sf_empresa ");
        sb.append("(nombre,finscripcion,rfc) ");
        sb.append("values (?,?,?)");
        

        try {
            //Connection con = Conexion.getConnection(); JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(sb.toString());

            ps.setString(index++, empresa.getRazonSocial().trim().toUpperCase());
            ps.setDate(index++, new java.sql.Date(empresa.getFinscripcion().getTime()));
            ps.setString(index++, empresa.getRfc().trim().toUpperCase());

            registrosAfectados = ps.executeUpdate();

            Conexion.closeConnection(con);
        } catch (SQLException sqle) {
            throw new AppException("Fallo al tratar "
                    + "de insertar los datos de la empresa.", sqle);
        }
    }

    /**
     * Regresa una collección de todos los empleados existentes.
     * @return Regresa una collección de todos los empleados existentes
     * @throws AppException
     */
    public static Collection selectEmpresa() throws AppException {
        ArrayList<Map> mapaSelect = new ArrayList<Map>();
        StringBuilder sbQuery = new StringBuilder();
        sbQuery.append("select rid,nombre,finscripcion,rfc from sf_empresa");

        try {
            //Connection con = Conexion.getConnection(); //JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(sbQuery.toString());
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                Map m = new HashMap();
                m.put("RID", rs.getInt("rid"));
                m.put("NOMBRE", rs.getString("nombre"));
                m.put("FINSCRIPCION", rs.getString("finscripcion"));
                m.put("RFC", rs.getString("rfc"));
                mapaSelect.add(m);
            }
            Conexion.closeConnection(con);
        } catch (SQLException sqle) {
            throw new AppException("Fallo al recuperar la lista "
                    + "de todos las empresas", sqle);
        }
        return mapaSelect;
    }

    /**
     * Elimina un empleado por RFC.
     *
     * @param rfc Solicita rfc
     * @throws AppException
     */
    public static void deleteEmpresa(String rfc) throws AppException {
        try {
            //Connection con = Conexion.getConnection(); JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(
                    "delete from sf_empresa where rfc = ?");
            ps.setString(1, rfc);
            registrosAfectados = ps.executeUpdate();
            Conexion.closeConnection(con);
        } catch (SQLException sqle) {
            throw new AppException("Fallo al eliminar el empleado", sqle);
        }
    }

    /**
     * Regresa un Map de los empleados si la CURP se encuentra.
     *
     * @param curp Solicita una curp
     * @return Regresa un Map de los registros solicitados por curp
     * @throws AppException
     */
    public static Map selectEmpresabyRFC(String curp) throws AppException {
        StringBuilder sbQuery = new StringBuilder();
        sbQuery.append("select rid,nombre,appaterno,apmaterno,fnacimiento,");
        sbQuery.append("email,nss,rfc,curp from sf_emp where curp=?");
        Map m = new HashMap();

        try {
            //Connection con = Conexion.getConnection(); JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(sbQuery.toString());
            ps.setString(1, curp);
            ResultSet rs = ps.executeQuery();

            if (rs.next()) {
                m.put("RID", rs.getInt("rid"));
                m.put("NOMBRE", rs.getString("nombre"));
                m.put("APPATERNO", rs.getString("appaterno"));
                m.put("APMATERNO", rs.getString("apmaterno"));
                m.put("FNACIMINETO", rs.getString("fnacimiento"));
                m.put("EMAIL", rs.getString("email"));
                m.put("NSS", rs.getString("nss"));
                m.put("RFC", rs.getString("rfc"));
                m.put("CURP", rs.getString("curp"));
            }

            Conexion.closeConnection(con);
        } catch (SQLException sqle) {
            throw new AppException("Fallo al recuperar los "
                    + "datos de un empleado.", sqle);
        }
        return m;
    }

    /**
     * Obtener si el existen duplicados en determinada columna CURP RFC o NSS.
     *
     * @param columna Nombre de columnas admitidas "curp" "rfc" y "nss"
     * @param elemento Solicitud de la cadena de texto dependiendo de la
     * columna.
     * @return Regresa true si encuentra datos dublicados en otro caso false.
     * @throws AppException
     */
    public static boolean getDuplicados(String columna, String elemento) throws AppException {
        boolean evaluarDuplicado = false;

        String query = "";
        if (columna.equals("curp")) {
            query = "select * from sf_emp where curp=?";
        } else if (columna.equals("rfc")) {
            query = "select * from sf_emp where rfc=?";
        } else if (columna.equals("nss")) {
            query = "select * from sf_emp where nss=?";
        }

        try {
            //Connection con = Conexion.getConnection(); JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(query);
            ps.setString(1, elemento);
            ResultSet rs = ps.executeQuery();
            evaluarDuplicado = rs.next();
            Conexion.closeConnection(con);

        } catch (SQLException sqle) {
            throw new AppException("Fallo al tratar de obtener "
                    + "los datos duplicados de la curp,rfc o nss.", sqle);
        }
        return evaluarDuplicado;
    }

    /**
     * Obtener si el RFC se encuntra duplicado en determinada CURP.
     *
     * @param RFC Solicita el RFC
     * @param CURP Solicita la CURP
     * @return Regresa true si encuentra datos dublicados en otro caso false.
     * @throws AppException
     */
    public static boolean getDuplicadoRFCbyCURP(String RFC, String CURP) throws AppException {
        boolean val = false;
        try {
            //Connection con = Conexion.getConnection(); //JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(
                    "select * from sf_emp where curp != ? and rfc = ?");
            ps.setString(1, CURP);
            ps.setString(2, RFC);
            ResultSet rs = ps.executeQuery();
            val = rs.next();
            Conexion.closeConnection(con);
        } catch (SQLException ex) {
            throw new AppException("Fallo al tratar de obtener los "
                    + "datos duplicados del rfc por medio de la curp.", ex);
        }
        return val;
    }

    /**
     *
     * @param arregloEmpleado
     * @throws AppException
     * @deprecated Actualmente no se esta utilizando.
     */
    public static void updateEmpleado(String[] arregloEmpleado) throws AppException {
        StringBuilder sb = new StringBuilder();
        int index = 1;
        sb.append("update sf_emp ");
        sb.append("set nombre = ?,appaterno = ?,apmaterno = ?,fnacimiento = ?");
        sb.append(",email = ?,nss = ?,rfc = ?) ");
        sb.append("where curp=?");

        java.sql.Date fecFormatoDate = null;
        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy", new Locale("es", "MX"));

        try {
            fecFormatoDate = new java.sql.Date(sdf.parse(String.valueOf(arregloEmpleado[3])).getTime());
        } catch (ParseException pe) {
            throw new AppException("Fallo al convertir formato de fecha", pe);
        }

        try {
            //Connection con = Conexion.getConnection(); JDBC
            Connection con = ConexionJNDI.getConnection(); //JNDI
            PreparedStatement ps = con.prepareStatement(sb.toString());

            ps.setString(index++, arregloEmpleado[0].trim().toUpperCase());
            ps.setString(index++, arregloEmpleado[1].trim().toUpperCase());
            ps.setString(index++, arregloEmpleado[2].trim().toUpperCase());
            ps.setDate(index++, fecFormatoDate);
            //ps.setDate(index++, sqlDate);
            ps.setString(index++, arregloEmpleado[4].trim().toLowerCase());
            ps.setString(index++, arregloEmpleado[5]);
            ps.setString(index++, arregloEmpleado[6].trim().toUpperCase());
            ps.setString(index++, arregloEmpleado[7].trim().toUpperCase());

            registrosAfectados = ps.executeUpdate();
            Conexion.closeConnection(con);

        } catch (SQLException ex) {
            throw new AppException("Fallo al tratar de actualizar los datos.", ex);
        }
    }
}